home *** CD-ROM | disk | FTP | other *** search
/ MacHack 1996 / MacHack 1996.toast / Presentations / Presentations ’91 / DAL Files / DALtool 6⁄6 (System 7.x) / DalDalInterface.c next >
Encoding:
C/C++ Source or Header  |  1991-06-19  |  6.5 KB  |  320 lines  |  [TEXT/KAHL]
  1. /* DAL handling routines */
  2.  
  3. #include <string.h>
  4. #include "DatabaseAccess.h"
  5. #include "DalDemo.h"
  6.  
  7. extern Rect gOutRect;
  8. extern CharsHandle gInText;
  9. long    sessionId;
  10. long    gTimer;
  11. long    gCounter;
  12. int        gDALState;
  13. Boolean    gDALActive, gDALMonitor, gDALNewCodeFrag;
  14.  
  15. /***Utility routines originally included to keep dependencies down on external
  16. object libraries***/
  17.  
  18. /***StrLen***/
  19. int StrLen(s)
  20. char *s;
  21. {
  22.     int n;
  23.     
  24.     for (n = 0; *s != '\0'; s++) n++;
  25.     return n;
  26. }
  27.  
  28. /***StrToOut***/
  29. void StrToOut(demoWind,str)
  30. demoPeek    demoWind;
  31. char        *str;
  32. {
  33.     long    len;
  34.     
  35.     if ((len = (long) StrLen(str)) != 0)
  36.     {
  37.         TESetSelect(32767,32767,demoWind->outputTE);
  38.         TEInsert(str,len,demoWind->outputTE);
  39.     }
  40. }
  41.  
  42. /***IntToOut***/
  43. void IntToOut(demoWind,num)
  44. demoPeek demoWind;
  45. int    num;
  46. {
  47.     int i,j,c,sign;
  48.     char    str[24];
  49.     
  50.     if ((sign = num) < 0)
  51.         num = -num;
  52.     i = 0;
  53.     do {
  54.         str[i++] = num % 10 + '0';
  55.     } while ((num /= 10) > 0);
  56.     if (sign < 0)
  57.         str[i++] = '-';
  58.     str[i] = '\0';
  59.     for (i = 0, j = StrLen(str); i < j; i++, j--)
  60.         c = str[i], str[i] = str[j-1], str[j-1] = c;
  61.     StrToOut(demoWind,str);
  62. }
  63.  
  64. /***NLToOut***/
  65. void NLToOut(demoWind)
  66. demoPeek    demoWind;
  67. {
  68.     TEKey(TE_CARRIAGE_RETURN,demoWind->outputTE);    
  69. }
  70.  
  71. /**Provide 'english' meaning to numeric messages ***/
  72. void DALTransErr(demoWind,err)
  73. demoPeek demoWind;
  74. int    err;
  75. {
  76.     switch (err)
  77.     {
  78.         case noErr:    StrToOut(demoWind,"OK/VAL ");
  79.                     break;
  80.         case rcDBNull:    StrToOut(demoWind,"NULL ");
  81.                     break;
  82.         case rcDBError:    StrToOut(demoWind,"ERROR ");
  83.                     break;
  84.         case rcDBValue:    StrToOut(demoWind,"READY ");
  85.                     break;
  86.         case rcDBBadType:    StrToOut(demoWind,"BADTYPE ");
  87.                     break;
  88.         case rcDBBreak:    StrToOut(demoWind,"BREAK ");
  89.                     break;
  90.         case rcDBExec:    StrToOut(demoWind,"EXEC ");
  91.                     break;
  92.         default:
  93.                 StrToOut(demoWind,"unknown error: ");
  94.                 IntToOut(demoWind,err);
  95.         }
  96. }
  97.         
  98. /***Create the session link with the server ***/
  99. void DALOpenLink(demoWind,node,user,pass)
  100. demoPeek demoWind;
  101. Str255 node, user, pass;
  102. {
  103.     int err;
  104.     Str63 ddevName = "DAL\0";
  105.     Str255 connStr = "";
  106.     
  107.     CtoPstr((char *)ddevName);
  108.     sessionId = -1L;
  109.     
  110.     err = DBInit(&sessionId, ddevName, node,user,pass,connStr,0L);
  111.     if (err != noErr)
  112.         DALErrorHandler(demoWind,err);
  113.     else
  114.     {
  115.         gDALActive = TRUE;
  116.         StrToOut(demoWind,"OpenLink:Connection established");
  117.         NLToOut(demoWind);
  118.     }
  119. }
  120.  
  121. /***DALSendExecute sends arbitrary fragment from input buffer and requests
  122. execution by the server if transmission was successful***/
  123.  
  124. void DALSendExecute(demoWind)
  125. demoPeek demoWind;
  126. {
  127.     short    len;
  128.     int err;
  129.     TEPtr    te;
  130.     
  131.     te = *(demoWind->curTE);
  132.     if ((len = te->teLength) == 0) return;
  133.  
  134.     SwitchToNewArea(demoWind);    
  135.     NLToOut(demoWind);
  136.     StrToOut(demoWind,"<Sending and Executing>");
  137.     NLToOut(demoWind);
  138.     TEPaste(demoWind->curTE);
  139.     NLToOut(demoWind);
  140.     AdjustScrollBar(demoWind);
  141.     SwitchToNewArea(demoWind);
  142.     gDALNewCodeFrag = TRUE;
  143.         
  144.     HLock((Handle)gInText);
  145.     err = DBSend(sessionId,**gInText,len,NIL);
  146.     HUnlock((Handle)gInText);
  147.     if (err != noErr)
  148.         DALErrorHandler(demoWind,err);
  149.     else
  150.     {
  151.         err = DBExec(sessionId,NIL);
  152.         if (err != noErr)
  153.             DALErrorHandler(demoWind,err);
  154.     }    
  155. }
  156.  
  157. /***DALMonitorState does just that on a periodic basis***/
  158. void DALMonitorState(demoWind)
  159. demoPeek demoWind;
  160. {
  161.     int    err;
  162.     long ticks;
  163.     
  164.     if ((ticks = TickCount()) >= gTimer)
  165.     {
  166.         gTimer += DAL_MONITOR_INTERVAL;
  167.         ++gCounter;
  168.         err = DBState(sessionId,NIL);
  169.         if (err == rcDBError && gDALNewCodeFrag)
  170.             DALErrorHandler(demoWind,err);
  171. /***new on 6/4 ****/
  172.         gDALState = err;
  173.         if (gDALMonitor) DALDisplayState(demoWind);
  174.         if (gDALState == rcDBValue && gDALNewCodeFrag) DALReadLink(demoWind);
  175.     }
  176. }    
  177.  
  178. /***DALErrorHandler***/
  179. void DALErrorHandler(demoWind,err)
  180. demoPeek demoWind;
  181. int err;
  182. {
  183.     long    errp;
  184.     long    err2p;
  185.     Str255    itm1;
  186.     Str255    itm2;
  187.     Str255    msg;
  188.     
  189.     gDALState = DBGetErr(sessionId, &errp, &err2p, itm1, itm2, msg,NIL);
  190.     NLToOut(demoWind);
  191.     DALTransErr(demoWind,err);
  192.     StrToOut(demoWind,msg);
  193.     NLToOut(demoWind);
  194.     gDALNewCodeFrag = FALSE;
  195. }
  196.  
  197. /***DALDisplayState***/
  198. void DALDisplayState(demoWind)
  199. demoPeek demoWind;
  200. {
  201.         DALTransErr(demoWind,gDALState);
  202. }
  203.  
  204. /***DALCloseSession provides a clean shutdown***/
  205. void DALCloseLink(demoWind)
  206. demoPeek demoWind;
  207. {
  208.     int err;
  209.     
  210.     err = DBEnd(sessionId,NIL);
  211.     if (err != noErr)
  212.         DALErrorHandler(demoWind,err);
  213.     else
  214.         gDALActive = FALSE;
  215. }
  216.  
  217. /***DALReadLink is an overly complex procedure to get data from the server***/
  218. void DALReadLink(demoWind)
  219. demoPeek    demoWind;
  220. {
  221.     DBType    typep;
  222.     short    lenp;
  223.     short    placep;
  224.     short    flagsp;
  225.     Ptr        buffer[DAL_MAXCOL];
  226.     int     err;
  227.     short    maxCol;
  228.     short    bIndex;
  229.     Boolean    firstRow;
  230.     
  231. /* do informational wait loop checking for data */
  232.  
  233.     firstRow = TRUE;
  234.     bIndex = 0;
  235.     maxCol = 0;
  236.     buffer[bIndex] = (Ptr) NIL;
  237.  
  238. /* double check that data is ready by using read-only mode of GetItem */
  239.     typep = typeAnyType;
  240.     err = DBGetItem(sessionId, DAL_MONITOR_INTERVAL/4, &typep, &lenp, &placep, &flagsp,
  241.                     NIL,NIL);
  242.     if (err < rcDBValue) return;
  243.  
  244.     StrToOut(demoWind,"<Reading Program Output>");
  245.     NLToOut(demoWind);
  246.     
  247.     while (err != rcDBError && err == rcDBValue)
  248.     {
  249.         typep = typeAnyType;
  250.         err = DBGetItem(sessionId, kDBWaitForever, &typep, &lenp, &placep, &flagsp,
  251.                         NIL,NIL);
  252.         if (err != rcDBValue) break;
  253.     /* if this is the first row, set up buffer space for each column's data */
  254.         if (firstRow)
  255.         {
  256.             switch (typep)
  257.             {
  258.                 case typeVChar:
  259.                 case typeChar:
  260.                         lenp += 1;    /* add one for null character termination */
  261.                         break;
  262.                 default:
  263.                         lenp = 8;
  264.                         break;
  265.             }
  266.             if ((buffer[bIndex] = NewPtr(lenp)) == NIL) ErrorHandler(NO_MEMORY);
  267.             /* check to see if this is the last colitem in this row...
  268.                 last time to grab pointers for this data request */
  269.             firstRow = !(flagsp & kDBLastColFlag);
  270.         }
  271.         else
  272.         {
  273.             switch (typep)
  274.             {
  275.                 case typeVChar:
  276.                 case typeChar:
  277.                         DisposPtr(buffer[bIndex]);
  278.                         lenp += 1;    /* add one for null character termination */
  279.                         if ((buffer[bIndex] = NewPtr(lenp)) == NIL) ErrorHandler(NO_MEMORY);
  280.                         break;
  281.                 default:
  282.                         break;
  283.             }
  284.         } /*else*/
  285.         if (bIndex > maxCol) maxCol = bIndex;
  286.         err = DBGetItem(sessionId, kDBWaitForever, &typep, &lenp, &placep, &flagsp,
  287.                         buffer[bIndex],NIL);        
  288.         if (err != rcDBValue && err != rcDBNull) break;
  289.         if (flagsp & kDBLastColFlag)
  290.         {
  291.             DALDisplayRow(demoWind,buffer,bIndex);
  292.             bIndex = 0;
  293.         }
  294.         else
  295.             ++bIndex;
  296.     } /*while*/
  297.     /* free up memory */
  298.     bIndex = 0;
  299.     while (maxCol-- >= 0)
  300.         DisposPtr(buffer[bIndex++]);
  301.     NLToOut(demoWind);
  302.  
  303. } /*DALReadLink*/
  304.  
  305. /***DALDisplayRow***/
  306. void DALDisplayRow(demoWind,buffer,bufLen)
  307. demoPeek demoWind;
  308. Ptr *buffer;
  309. int bufLen;
  310. {
  311.     int    i;
  312.     
  313.     for (i = 0; i <= bufLen; i++)
  314.     {
  315.         StrToOut(demoWind,(char *) buffer[i]);
  316.         StrToOut(demoWind," ");
  317.     }
  318.     
  319.     NLToOut(demoWind);
  320. }